package com.qen.repository;

import com.qen.common.BeetlUtils;
import com.qen.wrapper.Wrapper;
import org.beetl.sql.core.page.DefaultPageRequest;
import org.beetl.sql.core.page.PageRequest;
import org.beetl.sql.core.page.PageResult;

import java.util.List;
import java.util.Map;

/**
 * Join相关方法
 *
 * @author licz
 * @data 2025年06月03日 10:04 AM
 */
public interface JoinDao<T> {

    /**
     * 根据 Wrapper 条件，连表删除
     *
     * @param wrapper joinWrapper
     */
    int deleteJoin(Wrapper<T> wrapper);

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity  实体对象 (set 条件值,可以为 null)
     * @param wrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int updateJoin(T entity, Wrapper<T> wrapper);

    /**
     * 根据 whereEntity 条件，更新记录 (null字段也会更新 !!!)
     *
     * @param entity  实体对象 (set 条件值,可以为 null)
     * @param wrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int updateJoinAndNull(T entity, Wrapper<T> wrapper);

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param wrapper joinWrapper
     */
    Long selectJoinCount(Wrapper<T> wrapper);

    /**
     * 连表查询返回一条记录
     *
     * @param wrapper joinWrapper
     * @return T
     */
    default T selectJoinOne(Wrapper<T> wrapper) {
        return selectJoinOne(null, wrapper);
    }

    /**
     * 连表查询返回一条记录
     *
     * @param wrapper joinWrapper
     * @param clazz   resultType
     */
    default <DTO> DTO selectJoinOne(Class<DTO> clazz, Wrapper<T> wrapper) {
        PageResult page = selectJoinPage(DefaultPageRequest.of(0, 1, false), clazz, wrapper);
        List<DTO> list = page.getList();
        if (list.isEmpty()) {
            return null;
        } else {
            return list.get(0);
        }
    }

    /**
     * 连表查询返回Map
     *
     * @param wrapper joinWrapper
     */
    default Map<String, Object> selectJoinMap(Wrapper<T> wrapper) {
        //noinspection unchecked
        return selectJoinOne(Map.class, wrapper);
    }

    /**
     * 连表查询返回记录集合
     *
     * @param wrapper joinWrapper
     * @return List&lt;T&gt;
     */
    default List<T> selectJoinList(Wrapper<T> wrapper) {
        return selectJoinList(null, wrapper);
    }

    /**
     * 连表查询返回记录集合
     *
     * @param wrapper joinWrapper
     * @param clazz   resultType
     */
    default <DTO> List<DTO> selectJoinList(Class<DTO> clazz, Wrapper<T> wrapper) {
        return selectJoinPage(null, clazz, wrapper).getList();
    }

    /**
     * 连表查询返回Map集合
     *
     * @param wrapper joinWrapper
     */
    default List<Map<String, Object>> selectJoinMaps(Wrapper<T> wrapper) {
        return (List<Map<String, Object>>) ((Object) selectJoinList(Map.class, wrapper));
    }

    /**
     * 连表查询返回记录集合并分页
     *
     * @param wrapper joinWrapper
     */
    default <P extends PageRequest<T>> PageResult<T> selectJoinPage(P page, Wrapper<T> wrapper) {
        return selectJoinPage(page, null, wrapper);
    }

    /**
     * 连表查询返回记录集合并分页
     *
     * @param wrapper joinWrapper
     * @param clazz   resultType
     * @param <DTO>   分页返回对象
     */
    <DTO, P extends PageRequest<DTO>> PageResult<DTO> selectJoinPage(P page, Class<DTO> clazz, Wrapper<T> wrapper);

    /**
     * 连表查询返回Map集合并分页
     *
     * @param wrapper joinWrapper
     */
    default <P extends PageRequest<Map>> PageResult<Map<String, Object>> selectJoinMapsPage(P page, Wrapper<T> wrapper) {
        PageResult<Map> res = selectJoinPage(page, Map.class, wrapper);
        PageRequest request = DefaultPageRequest.of(page.getPageNumber(), page.getPageSize(), page.isTotalRequired(), page.isListRequired());
        PageResult<Map<String, Object>> result = request.of(BeetlUtils.convertResult(res.getList()), res.getTotalRow());
        return result;
    }

}
